/**
 * JZ UnoCSS - CSS规则生成器
 * 处理通用CSS规则生成和样式过滤
 * @version 1.0.0
 * @author jz
 */

/**
 * 生成通用CSS规则（不需要条件编译）
 * @param {string} selector - CSS选择器
 * @param {Object} styles - CSS样式对象
 * @param {Object} options - 选项
 * @returns {string} 通用CSS字符串
 */
export function generateUniversalCSSRule(selector, styles, options = {}) {
    const { mode = 'development' } = options;
    const isProduction = mode === 'production';
    
    // 过滤掉辅助属性（以__开头的属性）
    const filteredStyles = {};
    for (const [prop, value] of Object.entries(styles)) {
        if (!prop.startsWith('__')) {
            filteredStyles[prop] = value;
        }
    }
    
    if (Object.keys(filteredStyles).length === 0) {
        return '';
    }
    
    if (isProduction) {
        // 生产模式：压缩格式（一行）
        const cssProps = Object.entries(filteredStyles)
            .map(([prop, value]) => `${prop}:${value}`)
            .join(';');
        return `.${selector}{${cssProps}}`;
    } else {
        // 开发模式：格式化（多行）
        const cssProps = Object.entries(filteredStyles)
            .map(([prop, value]) => `  ${prop}: ${value};`)
            .join('\n');
        return `.${selector} {\n${cssProps}\n}`;
    }
}

/**
 * 生成完整的CSS内容（带注释头）
 * @param {string[]} cssRules - CSS规则数组
 * @param {string[]} classNames - 类名数组
 * @param {Array} classNameGroups - 类名组合数组
 * @param {Object} config - 配置对象
 * @param {Object} metadata - 元数据对象
 * @returns {string} 完整的CSS内容
 */
export function generateFullCSSContent(cssRules, classNames, classNameGroups, config, metadata = {}) {
    // 确保cssRules是数组
    if (!Array.isArray(cssRules)) {
        return [];
    }
    
    if (cssRules.length === 0) {
        return [];
    }
    
    // 确保参数是数组，避免访问undefined.length的错误
    const safeClassNames = Array.isArray(classNames) ? classNames : [];
    const safeClassNameGroups = Array.isArray(classNameGroups) ? classNameGroups : [];
    const safeConfig = config || {};
    
    // 统计特殊类名
    const specialClassNames = safeClassNames.filter(cls => /[/\[\]#(),%.]/.test(cls));
    const gradientGroups = safeClassNameGroups.filter(group => {
        const hasDirection = group.some(cls => {
            try {
                const decoded = cls.includes('LRSKODCMP') ? 
                    decodeURIComponent(cls.replace(/[LRSKODCMP]/g, match => {
                        const map = {'L': '/', 'R': '[', 'S': ']', 'K': '#', 'O': '(', 'D': ')', 'C': ',', 'M': '%', 'P': '.'};
                        return map[match] || match;
                    })) : cls;
                return decoded.match(/^bg-gradient-to-/);
            } catch {
                return false;
            }
        });
        const hasFrom = group.some(cls => {
            try {
                const decoded = cls.includes('LRSKODCMP') ? 
                    decodeURIComponent(cls.replace(/[LRSKODCMP]/g, match => {
                        const map = {'L': '/', 'R': '[', 'S': ']', 'K': '#', 'O': '(', 'D': ')', 'C': ',', 'M': '%', 'P': '.'};
                        return map[match] || match;
                    })) : cls;
                return decoded.match(/^from-/);
            } catch {
                return false;
            }
        });
        return hasDirection && hasFrom;
    });
    
    // 根据模式决定CSS内容格式
    const isProduction = safeConfig.mode === 'production';
    const generationType = metadata.generationType || '统一规则生成器';
    
    let cssContent;
    
    if (isProduction) {
        // 生产模式：极致压缩格式（去掉所有不必要的空格和空行）
        const minimalHeader = `/* JZ UnoCSS ${cssRules.length} rules */\n`;
        cssContent = minimalHeader + cssRules.join('');
    } else {
        // 开发模式：格式化（多行，详细注释）
        cssContent = `/* JZ UnoCSS - ${generationType} */
/* 生成时间: ${new Date().toLocaleString()} */
/* 处理文件: ${metadata.totalFiles || 0} 个 */
/* 唯一类名: ${safeClassNames.length} 个 */
/* 特殊类名: ${specialClassNames.length} 个 */
/* 渐变组合: ${gradientGroups.length} 个 */
/* 生成规则: ${cssRules.length} 条 */

${cssRules.join('\n\n')}
`;
    }
    
    // 在函数设计上，应该返回数组而不是字符串来避免调用方的类型错误
    // 但为了向后兼容，这里仍然返回字符串，由调用方处理
    return cssContent;
}

/**
 * 过滤CSS样式对象，移除辅助属性
 * @param {Object} styles - CSS样式对象
 * @returns {Object} 过滤后的样式对象
 */
export function filterCSSStyles(styles) {
    const filteredStyles = {};
    for (const [prop, value] of Object.entries(styles)) {
        if (!prop.startsWith('__')) {
            filteredStyles[prop] = value;
        }
    }
    return filteredStyles;
}

/**
 * 验证CSS规则是否有效
 * @param {string} cssRule - CSS规则字符串
 * @returns {boolean} 是否有效
 */
export function validateCSSRule(cssRule) {
    if (!cssRule || typeof cssRule !== 'string') {
        return false;
    }
    
    // 基本的CSS规则验证
    const hasSelector = cssRule.includes('{') && cssRule.includes('}');
    const hasProperty = cssRule.includes(':');
    
    return hasSelector && hasProperty;
} 